﻿using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using HslCommunication.BasicFramework;
using HslCommunication.Core;
using HslCommunication.Core.Net;
using HslCommunication.Reflection;

namespace HslCommunication.Serial
{
	/// <summary>
	/// 串口设备交互类的基类，实现了<see cref="T:HslCommunication.Core.IReadWriteNet" />接口的基础方法方法，需要使用继承重写来实现字节读写，bool读写操作。<br />
	/// The base class of the serial device interaction class, which implements the basic methods of the <see cref="T:HslCommunication.Core.IReadWriteNet" /> interface, 
	/// requires inheritance rewriting to implement byte read and write, and bool read and write operations.
	/// </summary>
	/// <remarks>
	/// 本类实现了不同的数据类型的读写交互的api，继承自本类，重写下面的四个方法将可以实现你自己的设备通信对象
	/// <list type="number">
	/// <item>
	/// <see cref="M:HslCommunication.Serial.SerialDeviceBase.Read(System.String,System.UInt16)" /> 方法，读取字节数组的方法。
	/// </item>
	/// <item>
	/// <see cref="M:HslCommunication.Serial.SerialDeviceBase.Write(System.String,System.Byte[])" /> 方法，写入字节数组的方法。
	/// </item>
	/// <item>
	/// <see cref="M:HslCommunication.Serial.SerialDeviceBase.ReadBool(System.String,System.UInt16)" /> 方法，读取bool数组的方法。
	/// </item>
	/// <item>
	/// <see cref="M:HslCommunication.Serial.SerialDeviceBase.Write(System.String,System.Boolean[])" /> 方法，写入bool数组的方法。
	/// </item>
	/// </list>
	/// 如果需要实现异步的方法。那就需要重写下面的四个方法。
	/// <list type="number">
	/// <item>
	/// <see cref="M:HslCommunication.Serial.SerialDeviceBase.ReadAsync(System.String,System.UInt16)" /> 方法，读取字节数组的方法。
	/// </item>
	/// <item>
	/// <see cref="M:HslCommunication.Serial.SerialDeviceBase.WriteAsync(System.String,System.Byte[])" /> 方法，写入字节数组的方法。
	/// </item>
	/// <item>
	/// <see cref="M:HslCommunication.Serial.SerialDeviceBase.ReadBoolAsync(System.String,System.UInt16)" /> 方法，读取bool数组的方法。
	/// </item>
	/// <item>
	/// <see cref="M:HslCommunication.Serial.SerialDeviceBase.WriteAsync(System.String,System.Boolean[])" /> 方法，写入bool数组的方法。
	/// </item>
	/// </list>
	/// </remarks>
	// Token: 0x0200002A RID: 42
	public class SerialDeviceBase : SerialBase, IReadWriteNet
	{
		/// <summary>
		/// 默认的构造方法实现的设备信息
		/// </summary>
		// Token: 0x060002AA RID: 682 RVA: 0x0000AB67 File Offset: 0x00008D67
		public SerialDeviceBase()
		{
			this.connectionId = SoftBasic.GetUniqueStringByGuidAndRandom();
		}

		/// <inheritdoc cref="P:HslCommunication.Core.Net.NetworkDoubleBase.ByteTransform" />
		// Token: 0x1700009A RID: 154
		// (get) Token: 0x060002AB RID: 683 RVA: 0x0000AB90 File Offset: 0x00008D90
		// (set) Token: 0x060002AC RID: 684 RVA: 0x0000ABA8 File Offset: 0x00008DA8
		public IByteTransform ByteTransform
		{
			get
			{
				return this.byteTransform;
			}
			set
			{
				this.byteTransform = value;
			}
		}

		/// <inheritdoc cref="P:HslCommunication.Core.Net.NetworkDoubleBase.ConnectionId" />
		// Token: 0x1700009B RID: 155
		// (get) Token: 0x060002AD RID: 685 RVA: 0x0000ABB4 File Offset: 0x00008DB4
		// (set) Token: 0x060002AE RID: 686 RVA: 0x0000ABCC File Offset: 0x00008DCC
		public string ConnectionId
		{
			get
			{
				return this.connectionId;
			}
			set
			{
				this.connectionId = value;
			}
		}

		/// <inheritdoc cref="P:HslCommunication.Core.Net.NetworkDeviceBase.WordLength" />
		// Token: 0x1700009C RID: 156
		// (get) Token: 0x060002AF RID: 687 RVA: 0x0000ABD6 File Offset: 0x00008DD6
		// (set) Token: 0x060002B0 RID: 688 RVA: 0x0000ABDE File Offset: 0x00008DDE
		protected ushort WordLength { get; set; } = 1;

		/// <inheritdoc />
		// Token: 0x060002B1 RID: 689 RVA: 0x0000ABE7 File Offset: 0x00008DE7
		public override string ToString()
		{
			return string.Format("SerialDeviceBase<{0}>", this.byteTransform.GetType());
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Read(System.String,System.UInt16)" />
		// Token: 0x060002B2 RID: 690 RVA: 0x0000ABFE File Offset: 0x00008DFE
		[HslMqttApi("ReadByteArray", "")]
		public virtual OperateResult<byte[]> Read(string address, ushort length)
		{
			return new OperateResult<byte[]>(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Byte[])" />
		// Token: 0x060002B3 RID: 691 RVA: 0x0000AC0F File Offset: 0x00008E0F
		[HslMqttApi("WriteByteArray", "")]
		public virtual OperateResult Write(string address, byte[] value)
		{
			return new OperateResult(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBool(System.String,System.UInt16)" />
		// Token: 0x060002B4 RID: 692 RVA: 0x0000AC20 File Offset: 0x00008E20
		[HslMqttApi("ReadBoolArray", "")]
		public virtual OperateResult<bool[]> ReadBool(string address, ushort length)
		{
			return new OperateResult<bool[]>(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBool(System.String)" />
		// Token: 0x060002B5 RID: 693 RVA: 0x0000AC31 File Offset: 0x00008E31
		[HslMqttApi("ReadBool", "")]
		public virtual OperateResult<bool> ReadBool(string address)
		{
			return ByteTransformHelper.GetResultFromArray<bool>(this.ReadBool(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Boolean[])" />
		// Token: 0x060002B6 RID: 694 RVA: 0x0000AC0F File Offset: 0x00008E0F
		[HslMqttApi("WriteBoolArray", "")]
		public virtual OperateResult Write(string address, bool[] value)
		{
			return new OperateResult(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Boolean)" />
		// Token: 0x060002B7 RID: 695 RVA: 0x0000AC40 File Offset: 0x00008E40
		[HslMqttApi("WriteBool", "")]
		public virtual OperateResult Write(string address, bool value)
		{
			return this.Write(address, new bool[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadCustomer``1(System.String)" />
		// Token: 0x060002B8 RID: 696 RVA: 0x0000AC54 File Offset: 0x00008E54
		public OperateResult<T> ReadCustomer<T>(string address) where T : IDataTransfer, new()
		{
			OperateResult<T> operateResult = new OperateResult<T>();
			T content = Activator.CreateInstance<T>();
			OperateResult<byte[]> operateResult2 = this.Read(address, content.ReadCount);
			bool isSuccess = operateResult2.IsSuccess;
			if (isSuccess)
			{
				content.ParseSource(operateResult2.Content);
				operateResult.Content = content;
				operateResult.IsSuccess = true;
			}
			else
			{
				operateResult.ErrorCode = operateResult2.ErrorCode;
				operateResult.Message = operateResult2.Message;
			}
			return operateResult;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteCustomer``1(System.String,``0)" />
		// Token: 0x060002B9 RID: 697 RVA: 0x0000ACD8 File Offset: 0x00008ED8
		public OperateResult WriteCustomer<T>(string address, T data) where T : IDataTransfer, new()
		{
			return this.Write(address, data.ToSource());
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Read``1" />
		// Token: 0x060002BA RID: 698 RVA: 0x0000ACEE File Offset: 0x00008EEE
		public virtual OperateResult<T> Read<T>() where T : class, new()
		{
			return HslReflectionHelper.Read<T>(this);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write``1(``0)" />
		// Token: 0x060002BB RID: 699 RVA: 0x0000ACF6 File Offset: 0x00008EF6
		public virtual OperateResult Write<T>(T data) where T : class, new()
		{
			return HslReflectionHelper.Write<T>(data, this);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16(System.String)" />
		// Token: 0x060002BC RID: 700 RVA: 0x0000ACFF File Offset: 0x00008EFF
		[HslMqttApi("ReadInt16", "")]
		public OperateResult<short> ReadInt16(string address)
		{
			return ByteTransformHelper.GetResultFromArray<short>(this.ReadInt16(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16(System.String,System.UInt16)" />
		// Token: 0x060002BD RID: 701 RVA: 0x0000AD10 File Offset: 0x00008F10
		[HslMqttApi("ReadInt16Array", "")]
		public virtual OperateResult<short[]> ReadInt16(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<short[]>(this.Read(address, length * this.WordLength), (byte[] m) => this.ByteTransform.TransInt16(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16(System.String)" />
		// Token: 0x060002BE RID: 702 RVA: 0x0000AD57 File Offset: 0x00008F57
		[HslMqttApi("ReadUInt16", "")]
		public OperateResult<ushort> ReadUInt16(string address)
		{
			return ByteTransformHelper.GetResultFromArray<ushort>(this.ReadUInt16(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16(System.String,System.UInt16)" />
		// Token: 0x060002BF RID: 703 RVA: 0x0000AD68 File Offset: 0x00008F68
		[HslMqttApi("ReadUInt16Array", "")]
		public virtual OperateResult<ushort[]> ReadUInt16(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<ushort[]>(this.Read(address, length * this.WordLength), (byte[] m) => this.ByteTransform.TransUInt16(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32(System.String)" />
		// Token: 0x060002C0 RID: 704 RVA: 0x0000ADAF File Offset: 0x00008FAF
		[HslMqttApi("ReadInt32", "")]
		public OperateResult<int> ReadInt32(string address)
		{
			return ByteTransformHelper.GetResultFromArray<int>(this.ReadInt32(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32(System.String,System.UInt16)" />
		// Token: 0x060002C1 RID: 705 RVA: 0x0000ADC0 File Offset: 0x00008FC0
		[HslMqttApi("ReadInt32Array", "")]
		public virtual OperateResult<int[]> ReadInt32(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<int[]>(this.Read(address, length * this.WordLength * 2), (byte[] m) => this.ByteTransform.TransInt32(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32(System.String)" />
		// Token: 0x060002C2 RID: 706 RVA: 0x0000AE09 File Offset: 0x00009009
		[HslMqttApi("ReadUInt32", "")]
		public OperateResult<uint> ReadUInt32(string address)
		{
			return ByteTransformHelper.GetResultFromArray<uint>(this.ReadUInt32(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32(System.String,System.UInt16)" />
		// Token: 0x060002C3 RID: 707 RVA: 0x0000AE18 File Offset: 0x00009018
		[HslMqttApi("ReadUInt32Array", "")]
		public virtual OperateResult<uint[]> ReadUInt32(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<uint[]>(this.Read(address, length * this.WordLength * 2), (byte[] m) => this.ByteTransform.TransUInt32(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloat(System.String)" />
		// Token: 0x060002C4 RID: 708 RVA: 0x0000AE61 File Offset: 0x00009061
		[HslMqttApi("ReadFloat", "")]
		public OperateResult<float> ReadFloat(string address)
		{
			return ByteTransformHelper.GetResultFromArray<float>(this.ReadFloat(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloat(System.String,System.UInt16)" />
		// Token: 0x060002C5 RID: 709 RVA: 0x0000AE70 File Offset: 0x00009070
		[HslMqttApi("ReadFloatArray", "")]
		public virtual OperateResult<float[]> ReadFloat(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<float[]>(this.Read(address, length * this.WordLength * 2), (byte[] m) => this.ByteTransform.TransSingle(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64(System.String)" />
		// Token: 0x060002C6 RID: 710 RVA: 0x0000AEB9 File Offset: 0x000090B9
		[HslMqttApi("ReadInt64", "")]
		public OperateResult<long> ReadInt64(string address)
		{
			return ByteTransformHelper.GetResultFromArray<long>(this.ReadInt64(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64(System.String,System.UInt16)" />
		// Token: 0x060002C7 RID: 711 RVA: 0x0000AEC8 File Offset: 0x000090C8
		[HslMqttApi("ReadInt64Array", "")]
		public virtual OperateResult<long[]> ReadInt64(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<long[]>(this.Read(address, length * this.WordLength * 4), (byte[] m) => this.ByteTransform.TransInt64(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64(System.String)" />
		// Token: 0x060002C8 RID: 712 RVA: 0x0000AF11 File Offset: 0x00009111
		[HslMqttApi("ReadUInt64", "")]
		public OperateResult<ulong> ReadUInt64(string address)
		{
			return ByteTransformHelper.GetResultFromArray<ulong>(this.ReadUInt64(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64(System.String,System.UInt16)" />
		// Token: 0x060002C9 RID: 713 RVA: 0x0000AF20 File Offset: 0x00009120
		[HslMqttApi("ReadUInt64Array", "")]
		public virtual OperateResult<ulong[]> ReadUInt64(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<ulong[]>(this.Read(address, length * this.WordLength * 4), (byte[] m) => this.ByteTransform.TransUInt64(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDouble(System.String)" />
		// Token: 0x060002CA RID: 714 RVA: 0x0000AF69 File Offset: 0x00009169
		[HslMqttApi("ReadDouble", "")]
		public OperateResult<double> ReadDouble(string address)
		{
			return ByteTransformHelper.GetResultFromArray<double>(this.ReadDouble(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDouble(System.String,System.UInt16)" />
		// Token: 0x060002CB RID: 715 RVA: 0x0000AF78 File Offset: 0x00009178
		[HslMqttApi("ReadDoubleArray", "")]
		public virtual OperateResult<double[]> ReadDouble(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<double[]>(this.Read(address, length * this.WordLength * 4), (byte[] m) => this.ByteTransform.TransDouble(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadString(System.String,System.UInt16)" />
		// Token: 0x060002CC RID: 716 RVA: 0x0000AFC1 File Offset: 0x000091C1
		[HslMqttApi("ReadString", "")]
		public OperateResult<string> ReadString(string address, ushort length)
		{
			return this.ReadString(address, length, Encoding.ASCII);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadString(System.String,System.UInt16,System.Text.Encoding)" />
		// Token: 0x060002CD RID: 717 RVA: 0x0000AFD0 File Offset: 0x000091D0
		public virtual OperateResult<string> ReadString(string address, ushort length, Encoding encoding)
		{
			return ByteTransformHelper.GetResultFromBytes<string>(this.Read(address, length), (byte[] m) => this.ByteTransform.TransString(m, 0, m.Length, encoding));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int16[])" />
		// Token: 0x060002CE RID: 718 RVA: 0x0000B00A File Offset: 0x0000920A
		[HslMqttApi("WriteInt16Array", "")]
		public virtual OperateResult Write(string address, short[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int16)" />
		// Token: 0x060002CF RID: 719 RVA: 0x0000B01F File Offset: 0x0000921F
		[HslMqttApi("WriteInt16", "")]
		public virtual OperateResult Write(string address, short value)
		{
			return this.Write(address, new short[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt16[])" />
		// Token: 0x060002D0 RID: 720 RVA: 0x0000B032 File Offset: 0x00009232
		[HslMqttApi("WriteUInt16Array", "")]
		public virtual OperateResult Write(string address, ushort[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt16)" />
		// Token: 0x060002D1 RID: 721 RVA: 0x0000B047 File Offset: 0x00009247
		[HslMqttApi("WriteUInt16", "")]
		public virtual OperateResult Write(string address, ushort value)
		{
			return this.Write(address, new ushort[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int32[])" />
		// Token: 0x060002D2 RID: 722 RVA: 0x0000B05A File Offset: 0x0000925A
		[HslMqttApi("WriteInt32Array", "")]
		public virtual OperateResult Write(string address, int[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int32)" />
		// Token: 0x060002D3 RID: 723 RVA: 0x0000B06F File Offset: 0x0000926F
		[HslMqttApi("WriteInt32", "")]
		public OperateResult Write(string address, int value)
		{
			return this.Write(address, new int[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt32[])" />
		// Token: 0x060002D4 RID: 724 RVA: 0x0000B082 File Offset: 0x00009282
		[HslMqttApi("WriteUInt32Array", "")]
		public virtual OperateResult Write(string address, uint[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt32)" />
		// Token: 0x060002D5 RID: 725 RVA: 0x0000B097 File Offset: 0x00009297
		[HslMqttApi("WriteUInt32", "")]
		public OperateResult Write(string address, uint value)
		{
			return this.Write(address, new uint[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Single[])" />
		// Token: 0x060002D6 RID: 726 RVA: 0x0000B0AA File Offset: 0x000092AA
		[HslMqttApi("WriteFloatArray", "")]
		public virtual OperateResult Write(string address, float[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Single)" />
		// Token: 0x060002D7 RID: 727 RVA: 0x0000B0BF File Offset: 0x000092BF
		[HslMqttApi("WriteFloat", "")]
		public OperateResult Write(string address, float value)
		{
			return this.Write(address, new float[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int64[])" />
		// Token: 0x060002D8 RID: 728 RVA: 0x0000B0D2 File Offset: 0x000092D2
		[HslMqttApi("WriteInt64Array", "")]
		public virtual OperateResult Write(string address, long[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int64)" />
		// Token: 0x060002D9 RID: 729 RVA: 0x0000B0E7 File Offset: 0x000092E7
		[HslMqttApi("WriteInt64", "")]
		public OperateResult Write(string address, long value)
		{
			return this.Write(address, new long[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt64[])" />
		// Token: 0x060002DA RID: 730 RVA: 0x0000B0FA File Offset: 0x000092FA
		[HslMqttApi("WriteUInt64Array", "")]
		public virtual OperateResult Write(string address, ulong[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt64)" />
		// Token: 0x060002DB RID: 731 RVA: 0x0000B10F File Offset: 0x0000930F
		[HslMqttApi("WriteUInt64", "")]
		public OperateResult Write(string address, ulong value)
		{
			return this.Write(address, new ulong[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Double[])" />
		// Token: 0x060002DC RID: 732 RVA: 0x0000B122 File Offset: 0x00009322
		[HslMqttApi("WriteDoubleArray", "")]
		public virtual OperateResult Write(string address, double[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Double)" />
		// Token: 0x060002DD RID: 733 RVA: 0x0000B137 File Offset: 0x00009337
		[HslMqttApi("WriteDouble", "")]
		public OperateResult Write(string address, double value)
		{
			return this.Write(address, new double[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String)" />
		// Token: 0x060002DE RID: 734 RVA: 0x0000B14A File Offset: 0x0000934A
		[HslMqttApi("WriteString", "")]
		public virtual OperateResult Write(string address, string value)
		{
			return this.Write(address, value, Encoding.ASCII);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String,System.Int32)" />
		// Token: 0x060002DF RID: 735 RVA: 0x0000B159 File Offset: 0x00009359
		public virtual OperateResult Write(string address, string value, int length)
		{
			return this.Write(address, value, length, Encoding.ASCII);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String,System.Text.Encoding)" />
		// Token: 0x060002E0 RID: 736 RVA: 0x0000B16C File Offset: 0x0000936C
		public virtual OperateResult Write(string address, string value, Encoding encoding)
		{
			byte[] array = this.ByteTransform.TransByte(value, encoding);
			bool flag = this.WordLength == 1;
			if (flag)
			{
				array = SoftBasic.ArrayExpandToLengthEven<byte>(array);
			}
			return this.Write(address, array);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String,System.Int32,System.Text.Encoding)" />
		// Token: 0x060002E1 RID: 737 RVA: 0x0000B1A8 File Offset: 0x000093A8
		public virtual OperateResult Write(string address, string value, int length, Encoding encoding)
		{
			byte[] array = this.ByteTransform.TransByte(value, encoding);
			bool flag = this.WordLength == 1;
			if (flag)
			{
				array = SoftBasic.ArrayExpandToLengthEven<byte>(array);
			}
			array = SoftBasic.ArrayExpandToLength<byte>(array, length);
			return this.Write(address, array);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Boolean,System.Int32,System.Int32)" />
		// Token: 0x060002E2 RID: 738 RVA: 0x0000B1ED File Offset: 0x000093ED
		[HslMqttApi("WaitBool", "")]
		public OperateResult<TimeSpan> Wait(string address, bool waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int16,System.Int32,System.Int32)" />
		// Token: 0x060002E3 RID: 739 RVA: 0x0000B1FA File Offset: 0x000093FA
		[HslMqttApi("WaitInt16", "")]
		public OperateResult<TimeSpan> Wait(string address, short waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt16,System.Int32,System.Int32)" />
		// Token: 0x060002E4 RID: 740 RVA: 0x0000B207 File Offset: 0x00009407
		[HslMqttApi("WaitUInt16", "")]
		public OperateResult<TimeSpan> Wait(string address, ushort waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int32,System.Int32,System.Int32)" />
		// Token: 0x060002E5 RID: 741 RVA: 0x0000B214 File Offset: 0x00009414
		[HslMqttApi("WaitInt32", "")]
		public OperateResult<TimeSpan> Wait(string address, int waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt32,System.Int32,System.Int32)" />
		// Token: 0x060002E6 RID: 742 RVA: 0x0000B221 File Offset: 0x00009421
		[HslMqttApi("WaitUInt32", "")]
		public OperateResult<TimeSpan> Wait(string address, uint waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int64,System.Int32,System.Int32)" />
		// Token: 0x060002E7 RID: 743 RVA: 0x0000B22E File Offset: 0x0000942E
		[HslMqttApi("WaitInt64", "")]
		public OperateResult<TimeSpan> Wait(string address, long waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt64,System.Int32,System.Int32)" />
		// Token: 0x060002E8 RID: 744 RVA: 0x0000B23B File Offset: 0x0000943B
		[HslMqttApi("WaitUInt64", "")]
		public OperateResult<TimeSpan> Wait(string address, ulong waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Boolean,System.Int32,System.Int32)" />
		// Token: 0x060002E9 RID: 745 RVA: 0x0000B248 File Offset: 0x00009448
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, bool waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			SerialDeviceBase.<WaitAsync>d__69 <WaitAsync>d__ = new SerialDeviceBase.<WaitAsync>d__69();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<SerialDeviceBase.<WaitAsync>d__69>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int16,System.Int32,System.Int32)" />
		// Token: 0x060002EA RID: 746 RVA: 0x0000B2AC File Offset: 0x000094AC
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, short waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			SerialDeviceBase.<WaitAsync>d__70 <WaitAsync>d__ = new SerialDeviceBase.<WaitAsync>d__70();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<SerialDeviceBase.<WaitAsync>d__70>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt16,System.Int32,System.Int32)" />
		// Token: 0x060002EB RID: 747 RVA: 0x0000B310 File Offset: 0x00009510
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, ushort waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			SerialDeviceBase.<WaitAsync>d__71 <WaitAsync>d__ = new SerialDeviceBase.<WaitAsync>d__71();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<SerialDeviceBase.<WaitAsync>d__71>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int32,System.Int32,System.Int32)" />
		// Token: 0x060002EC RID: 748 RVA: 0x0000B374 File Offset: 0x00009574
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, int waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			SerialDeviceBase.<WaitAsync>d__72 <WaitAsync>d__ = new SerialDeviceBase.<WaitAsync>d__72();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<SerialDeviceBase.<WaitAsync>d__72>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt32,System.Int32,System.Int32)" />
		// Token: 0x060002ED RID: 749 RVA: 0x0000B3D8 File Offset: 0x000095D8
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, uint waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			SerialDeviceBase.<WaitAsync>d__73 <WaitAsync>d__ = new SerialDeviceBase.<WaitAsync>d__73();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<SerialDeviceBase.<WaitAsync>d__73>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int64,System.Int32,System.Int32)" />
		// Token: 0x060002EE RID: 750 RVA: 0x0000B43C File Offset: 0x0000963C
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, long waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			SerialDeviceBase.<WaitAsync>d__74 <WaitAsync>d__ = new SerialDeviceBase.<WaitAsync>d__74();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<SerialDeviceBase.<WaitAsync>d__74>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt64,System.Int32,System.Int32)" />
		// Token: 0x060002EF RID: 751 RVA: 0x0000B4A0 File Offset: 0x000096A0
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, ulong waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			SerialDeviceBase.<WaitAsync>d__75 <WaitAsync>d__ = new SerialDeviceBase.<WaitAsync>d__75();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<SerialDeviceBase.<WaitAsync>d__75>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadAsync(System.String,System.UInt16)" />
		// Token: 0x060002F0 RID: 752 RVA: 0x0000B504 File Offset: 0x00009704
		[DebuggerStepThrough]
		public virtual Task<OperateResult<byte[]>> ReadAsync(string address, ushort length)
		{
			SerialDeviceBase.<ReadAsync>d__76 <ReadAsync>d__ = new SerialDeviceBase.<ReadAsync>d__76();
			<ReadAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<byte[]>>.Create();
			<ReadAsync>d__.<>4__this = this;
			<ReadAsync>d__.address = address;
			<ReadAsync>d__.length = length;
			<ReadAsync>d__.<>1__state = -1;
			<ReadAsync>d__.<>t__builder.Start<SerialDeviceBase.<ReadAsync>d__76>(ref <ReadAsync>d__);
			return <ReadAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Byte[])" />
		// Token: 0x060002F1 RID: 753 RVA: 0x0000B558 File Offset: 0x00009758
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, byte[] value)
		{
			SerialDeviceBase.<WriteAsync>d__77 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__77();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__77>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBoolAsync(System.String,System.UInt16)" />
		// Token: 0x060002F2 RID: 754 RVA: 0x0000B5AC File Offset: 0x000097AC
		[DebuggerStepThrough]
		public virtual Task<OperateResult<bool[]>> ReadBoolAsync(string address, ushort length)
		{
			SerialDeviceBase.<ReadBoolAsync>d__78 <ReadBoolAsync>d__ = new SerialDeviceBase.<ReadBoolAsync>d__78();
			<ReadBoolAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<bool[]>>.Create();
			<ReadBoolAsync>d__.<>4__this = this;
			<ReadBoolAsync>d__.address = address;
			<ReadBoolAsync>d__.length = length;
			<ReadBoolAsync>d__.<>1__state = -1;
			<ReadBoolAsync>d__.<>t__builder.Start<SerialDeviceBase.<ReadBoolAsync>d__78>(ref <ReadBoolAsync>d__);
			return <ReadBoolAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBoolAsync(System.String)" />
		// Token: 0x060002F3 RID: 755 RVA: 0x0000B600 File Offset: 0x00009800
		[DebuggerStepThrough]
		public virtual Task<OperateResult<bool>> ReadBoolAsync(string address)
		{
			SerialDeviceBase.<ReadBoolAsync>d__79 <ReadBoolAsync>d__ = new SerialDeviceBase.<ReadBoolAsync>d__79();
			<ReadBoolAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<bool>>.Create();
			<ReadBoolAsync>d__.<>4__this = this;
			<ReadBoolAsync>d__.address = address;
			<ReadBoolAsync>d__.<>1__state = -1;
			<ReadBoolAsync>d__.<>t__builder.Start<SerialDeviceBase.<ReadBoolAsync>d__79>(ref <ReadBoolAsync>d__);
			return <ReadBoolAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Boolean[])" />
		// Token: 0x060002F4 RID: 756 RVA: 0x0000B64C File Offset: 0x0000984C
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, bool[] value)
		{
			SerialDeviceBase.<WriteAsync>d__80 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__80();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__80>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Boolean)" />
		// Token: 0x060002F5 RID: 757 RVA: 0x0000B6A0 File Offset: 0x000098A0
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, bool value)
		{
			SerialDeviceBase.<WriteAsync>d__81 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__81();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__81>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteCustomerAsync``1(System.String,``0)" />
		// Token: 0x060002F6 RID: 758 RVA: 0x0000B6F4 File Offset: 0x000098F4
		[DebuggerStepThrough]
		public Task<OperateResult<T>> ReadCustomerAsync<T>(string address) where T : IDataTransfer, new()
		{
			SerialDeviceBase.<ReadCustomerAsync>d__82<T> <ReadCustomerAsync>d__ = new SerialDeviceBase.<ReadCustomerAsync>d__82<T>();
			<ReadCustomerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<T>>.Create();
			<ReadCustomerAsync>d__.<>4__this = this;
			<ReadCustomerAsync>d__.address = address;
			<ReadCustomerAsync>d__.<>1__state = -1;
			<ReadCustomerAsync>d__.<>t__builder.Start<SerialDeviceBase.<ReadCustomerAsync>d__82<T>>(ref <ReadCustomerAsync>d__);
			return <ReadCustomerAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteCustomerAsync``1(System.String,``0)" />
		// Token: 0x060002F7 RID: 759 RVA: 0x0000B740 File Offset: 0x00009940
		[DebuggerStepThrough]
		public Task<OperateResult> WriteCustomerAsync<T>(string address, T data) where T : IDataTransfer, new()
		{
			SerialDeviceBase.<WriteCustomerAsync>d__83<T> <WriteCustomerAsync>d__ = new SerialDeviceBase.<WriteCustomerAsync>d__83<T>();
			<WriteCustomerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteCustomerAsync>d__.<>4__this = this;
			<WriteCustomerAsync>d__.address = address;
			<WriteCustomerAsync>d__.data = data;
			<WriteCustomerAsync>d__.<>1__state = -1;
			<WriteCustomerAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteCustomerAsync>d__83<T>>(ref <WriteCustomerAsync>d__);
			return <WriteCustomerAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadAsync``1" />
		// Token: 0x060002F8 RID: 760 RVA: 0x0000B794 File Offset: 0x00009994
		[DebuggerStepThrough]
		public virtual Task<OperateResult<T>> ReadAsync<T>() where T : class, new()
		{
			SerialDeviceBase.<ReadAsync>d__84<T> <ReadAsync>d__ = new SerialDeviceBase.<ReadAsync>d__84<T>();
			<ReadAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<T>>.Create();
			<ReadAsync>d__.<>4__this = this;
			<ReadAsync>d__.<>1__state = -1;
			<ReadAsync>d__.<>t__builder.Start<SerialDeviceBase.<ReadAsync>d__84<T>>(ref <ReadAsync>d__);
			return <ReadAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync``1(``0)" />
		// Token: 0x060002F9 RID: 761 RVA: 0x0000B7D8 File Offset: 0x000099D8
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync<T>(T data) where T : class, new()
		{
			SerialDeviceBase.<WriteAsync>d__85<T> <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__85<T>();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.data = data;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__85<T>>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16Async(System.String)" />
		// Token: 0x060002FA RID: 762 RVA: 0x0000B824 File Offset: 0x00009A24
		[DebuggerStepThrough]
		public Task<OperateResult<short>> ReadInt16Async(string address)
		{
			SerialDeviceBase.<ReadInt16Async>d__86 <ReadInt16Async>d__ = new SerialDeviceBase.<ReadInt16Async>d__86();
			<ReadInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<short>>.Create();
			<ReadInt16Async>d__.<>4__this = this;
			<ReadInt16Async>d__.address = address;
			<ReadInt16Async>d__.<>1__state = -1;
			<ReadInt16Async>d__.<>t__builder.Start<SerialDeviceBase.<ReadInt16Async>d__86>(ref <ReadInt16Async>d__);
			return <ReadInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16Async(System.String,System.UInt16)" />
		// Token: 0x060002FB RID: 763 RVA: 0x0000B870 File Offset: 0x00009A70
		[DebuggerStepThrough]
		public virtual Task<OperateResult<short[]>> ReadInt16Async(string address, ushort length)
		{
			SerialDeviceBase.<ReadInt16Async>d__87 <ReadInt16Async>d__ = new SerialDeviceBase.<ReadInt16Async>d__87();
			<ReadInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<short[]>>.Create();
			<ReadInt16Async>d__.<>4__this = this;
			<ReadInt16Async>d__.address = address;
			<ReadInt16Async>d__.length = length;
			<ReadInt16Async>d__.<>1__state = -1;
			<ReadInt16Async>d__.<>t__builder.Start<SerialDeviceBase.<ReadInt16Async>d__87>(ref <ReadInt16Async>d__);
			return <ReadInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16Async(System.String)" />
		// Token: 0x060002FC RID: 764 RVA: 0x0000B8C4 File Offset: 0x00009AC4
		[DebuggerStepThrough]
		public Task<OperateResult<ushort>> ReadUInt16Async(string address)
		{
			SerialDeviceBase.<ReadUInt16Async>d__88 <ReadUInt16Async>d__ = new SerialDeviceBase.<ReadUInt16Async>d__88();
			<ReadUInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ushort>>.Create();
			<ReadUInt16Async>d__.<>4__this = this;
			<ReadUInt16Async>d__.address = address;
			<ReadUInt16Async>d__.<>1__state = -1;
			<ReadUInt16Async>d__.<>t__builder.Start<SerialDeviceBase.<ReadUInt16Async>d__88>(ref <ReadUInt16Async>d__);
			return <ReadUInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16Async(System.String,System.UInt16)" />
		// Token: 0x060002FD RID: 765 RVA: 0x0000B910 File Offset: 0x00009B10
		[DebuggerStepThrough]
		public virtual Task<OperateResult<ushort[]>> ReadUInt16Async(string address, ushort length)
		{
			SerialDeviceBase.<ReadUInt16Async>d__89 <ReadUInt16Async>d__ = new SerialDeviceBase.<ReadUInt16Async>d__89();
			<ReadUInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ushort[]>>.Create();
			<ReadUInt16Async>d__.<>4__this = this;
			<ReadUInt16Async>d__.address = address;
			<ReadUInt16Async>d__.length = length;
			<ReadUInt16Async>d__.<>1__state = -1;
			<ReadUInt16Async>d__.<>t__builder.Start<SerialDeviceBase.<ReadUInt16Async>d__89>(ref <ReadUInt16Async>d__);
			return <ReadUInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32Async(System.String)" />
		// Token: 0x060002FE RID: 766 RVA: 0x0000B964 File Offset: 0x00009B64
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ReadInt32Async(string address)
		{
			SerialDeviceBase.<ReadInt32Async>d__90 <ReadInt32Async>d__ = new SerialDeviceBase.<ReadInt32Async>d__90();
			<ReadInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ReadInt32Async>d__.<>4__this = this;
			<ReadInt32Async>d__.address = address;
			<ReadInt32Async>d__.<>1__state = -1;
			<ReadInt32Async>d__.<>t__builder.Start<SerialDeviceBase.<ReadInt32Async>d__90>(ref <ReadInt32Async>d__);
			return <ReadInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32Async(System.String,System.UInt16)" />
		// Token: 0x060002FF RID: 767 RVA: 0x0000B9B0 File Offset: 0x00009BB0
		[DebuggerStepThrough]
		public virtual Task<OperateResult<int[]>> ReadInt32Async(string address, ushort length)
		{
			SerialDeviceBase.<ReadInt32Async>d__91 <ReadInt32Async>d__ = new SerialDeviceBase.<ReadInt32Async>d__91();
			<ReadInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int[]>>.Create();
			<ReadInt32Async>d__.<>4__this = this;
			<ReadInt32Async>d__.address = address;
			<ReadInt32Async>d__.length = length;
			<ReadInt32Async>d__.<>1__state = -1;
			<ReadInt32Async>d__.<>t__builder.Start<SerialDeviceBase.<ReadInt32Async>d__91>(ref <ReadInt32Async>d__);
			return <ReadInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32Async(System.String)" />
		// Token: 0x06000300 RID: 768 RVA: 0x0000BA04 File Offset: 0x00009C04
		[DebuggerStepThrough]
		public Task<OperateResult<uint>> ReadUInt32Async(string address)
		{
			SerialDeviceBase.<ReadUInt32Async>d__92 <ReadUInt32Async>d__ = new SerialDeviceBase.<ReadUInt32Async>d__92();
			<ReadUInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<uint>>.Create();
			<ReadUInt32Async>d__.<>4__this = this;
			<ReadUInt32Async>d__.address = address;
			<ReadUInt32Async>d__.<>1__state = -1;
			<ReadUInt32Async>d__.<>t__builder.Start<SerialDeviceBase.<ReadUInt32Async>d__92>(ref <ReadUInt32Async>d__);
			return <ReadUInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32Async(System.String,System.UInt16)" />
		// Token: 0x06000301 RID: 769 RVA: 0x0000BA50 File Offset: 0x00009C50
		[DebuggerStepThrough]
		public virtual Task<OperateResult<uint[]>> ReadUInt32Async(string address, ushort length)
		{
			SerialDeviceBase.<ReadUInt32Async>d__93 <ReadUInt32Async>d__ = new SerialDeviceBase.<ReadUInt32Async>d__93();
			<ReadUInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<uint[]>>.Create();
			<ReadUInt32Async>d__.<>4__this = this;
			<ReadUInt32Async>d__.address = address;
			<ReadUInt32Async>d__.length = length;
			<ReadUInt32Async>d__.<>1__state = -1;
			<ReadUInt32Async>d__.<>t__builder.Start<SerialDeviceBase.<ReadUInt32Async>d__93>(ref <ReadUInt32Async>d__);
			return <ReadUInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloatAsync(System.String)" />
		// Token: 0x06000302 RID: 770 RVA: 0x0000BAA4 File Offset: 0x00009CA4
		[DebuggerStepThrough]
		public Task<OperateResult<float>> ReadFloatAsync(string address)
		{
			SerialDeviceBase.<ReadFloatAsync>d__94 <ReadFloatAsync>d__ = new SerialDeviceBase.<ReadFloatAsync>d__94();
			<ReadFloatAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<float>>.Create();
			<ReadFloatAsync>d__.<>4__this = this;
			<ReadFloatAsync>d__.address = address;
			<ReadFloatAsync>d__.<>1__state = -1;
			<ReadFloatAsync>d__.<>t__builder.Start<SerialDeviceBase.<ReadFloatAsync>d__94>(ref <ReadFloatAsync>d__);
			return <ReadFloatAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloatAsync(System.String,System.UInt16)" />
		// Token: 0x06000303 RID: 771 RVA: 0x0000BAF0 File Offset: 0x00009CF0
		[DebuggerStepThrough]
		public virtual Task<OperateResult<float[]>> ReadFloatAsync(string address, ushort length)
		{
			SerialDeviceBase.<ReadFloatAsync>d__95 <ReadFloatAsync>d__ = new SerialDeviceBase.<ReadFloatAsync>d__95();
			<ReadFloatAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<float[]>>.Create();
			<ReadFloatAsync>d__.<>4__this = this;
			<ReadFloatAsync>d__.address = address;
			<ReadFloatAsync>d__.length = length;
			<ReadFloatAsync>d__.<>1__state = -1;
			<ReadFloatAsync>d__.<>t__builder.Start<SerialDeviceBase.<ReadFloatAsync>d__95>(ref <ReadFloatAsync>d__);
			return <ReadFloatAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64Async(System.String)" />
		// Token: 0x06000304 RID: 772 RVA: 0x0000BB44 File Offset: 0x00009D44
		[DebuggerStepThrough]
		public Task<OperateResult<long>> ReadInt64Async(string address)
		{
			SerialDeviceBase.<ReadInt64Async>d__96 <ReadInt64Async>d__ = new SerialDeviceBase.<ReadInt64Async>d__96();
			<ReadInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<ReadInt64Async>d__.<>4__this = this;
			<ReadInt64Async>d__.address = address;
			<ReadInt64Async>d__.<>1__state = -1;
			<ReadInt64Async>d__.<>t__builder.Start<SerialDeviceBase.<ReadInt64Async>d__96>(ref <ReadInt64Async>d__);
			return <ReadInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64Async(System.String,System.UInt16)" />
		// Token: 0x06000305 RID: 773 RVA: 0x0000BB90 File Offset: 0x00009D90
		[DebuggerStepThrough]
		public virtual Task<OperateResult<long[]>> ReadInt64Async(string address, ushort length)
		{
			SerialDeviceBase.<ReadInt64Async>d__97 <ReadInt64Async>d__ = new SerialDeviceBase.<ReadInt64Async>d__97();
			<ReadInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long[]>>.Create();
			<ReadInt64Async>d__.<>4__this = this;
			<ReadInt64Async>d__.address = address;
			<ReadInt64Async>d__.length = length;
			<ReadInt64Async>d__.<>1__state = -1;
			<ReadInt64Async>d__.<>t__builder.Start<SerialDeviceBase.<ReadInt64Async>d__97>(ref <ReadInt64Async>d__);
			return <ReadInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64Async(System.String)" />
		// Token: 0x06000306 RID: 774 RVA: 0x0000BBE4 File Offset: 0x00009DE4
		[DebuggerStepThrough]
		public Task<OperateResult<ulong>> ReadUInt64Async(string address)
		{
			SerialDeviceBase.<ReadUInt64Async>d__98 <ReadUInt64Async>d__ = new SerialDeviceBase.<ReadUInt64Async>d__98();
			<ReadUInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ulong>>.Create();
			<ReadUInt64Async>d__.<>4__this = this;
			<ReadUInt64Async>d__.address = address;
			<ReadUInt64Async>d__.<>1__state = -1;
			<ReadUInt64Async>d__.<>t__builder.Start<SerialDeviceBase.<ReadUInt64Async>d__98>(ref <ReadUInt64Async>d__);
			return <ReadUInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64Async(System.String,System.UInt16)" />
		// Token: 0x06000307 RID: 775 RVA: 0x0000BC30 File Offset: 0x00009E30
		[DebuggerStepThrough]
		public virtual Task<OperateResult<ulong[]>> ReadUInt64Async(string address, ushort length)
		{
			SerialDeviceBase.<ReadUInt64Async>d__99 <ReadUInt64Async>d__ = new SerialDeviceBase.<ReadUInt64Async>d__99();
			<ReadUInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ulong[]>>.Create();
			<ReadUInt64Async>d__.<>4__this = this;
			<ReadUInt64Async>d__.address = address;
			<ReadUInt64Async>d__.length = length;
			<ReadUInt64Async>d__.<>1__state = -1;
			<ReadUInt64Async>d__.<>t__builder.Start<SerialDeviceBase.<ReadUInt64Async>d__99>(ref <ReadUInt64Async>d__);
			return <ReadUInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDoubleAsync(System.String)" />
		// Token: 0x06000308 RID: 776 RVA: 0x0000BC84 File Offset: 0x00009E84
		[DebuggerStepThrough]
		public Task<OperateResult<double>> ReadDoubleAsync(string address)
		{
			SerialDeviceBase.<ReadDoubleAsync>d__100 <ReadDoubleAsync>d__ = new SerialDeviceBase.<ReadDoubleAsync>d__100();
			<ReadDoubleAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<double>>.Create();
			<ReadDoubleAsync>d__.<>4__this = this;
			<ReadDoubleAsync>d__.address = address;
			<ReadDoubleAsync>d__.<>1__state = -1;
			<ReadDoubleAsync>d__.<>t__builder.Start<SerialDeviceBase.<ReadDoubleAsync>d__100>(ref <ReadDoubleAsync>d__);
			return <ReadDoubleAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDoubleAsync(System.String,System.UInt16)" />
		// Token: 0x06000309 RID: 777 RVA: 0x0000BCD0 File Offset: 0x00009ED0
		[DebuggerStepThrough]
		public virtual Task<OperateResult<double[]>> ReadDoubleAsync(string address, ushort length)
		{
			SerialDeviceBase.<ReadDoubleAsync>d__101 <ReadDoubleAsync>d__ = new SerialDeviceBase.<ReadDoubleAsync>d__101();
			<ReadDoubleAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<double[]>>.Create();
			<ReadDoubleAsync>d__.<>4__this = this;
			<ReadDoubleAsync>d__.address = address;
			<ReadDoubleAsync>d__.length = length;
			<ReadDoubleAsync>d__.<>1__state = -1;
			<ReadDoubleAsync>d__.<>t__builder.Start<SerialDeviceBase.<ReadDoubleAsync>d__101>(ref <ReadDoubleAsync>d__);
			return <ReadDoubleAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadStringAsync(System.String,System.UInt16)" />
		// Token: 0x0600030A RID: 778 RVA: 0x0000BD24 File Offset: 0x00009F24
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadStringAsync(string address, ushort length)
		{
			SerialDeviceBase.<ReadStringAsync>d__102 <ReadStringAsync>d__ = new SerialDeviceBase.<ReadStringAsync>d__102();
			<ReadStringAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadStringAsync>d__.<>4__this = this;
			<ReadStringAsync>d__.address = address;
			<ReadStringAsync>d__.length = length;
			<ReadStringAsync>d__.<>1__state = -1;
			<ReadStringAsync>d__.<>t__builder.Start<SerialDeviceBase.<ReadStringAsync>d__102>(ref <ReadStringAsync>d__);
			return <ReadStringAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadStringAsync(System.String,System.UInt16,System.Text.Encoding)" />
		// Token: 0x0600030B RID: 779 RVA: 0x0000BD78 File Offset: 0x00009F78
		[DebuggerStepThrough]
		public virtual Task<OperateResult<string>> ReadStringAsync(string address, ushort length, Encoding encoding)
		{
			SerialDeviceBase.<ReadStringAsync>d__103 <ReadStringAsync>d__ = new SerialDeviceBase.<ReadStringAsync>d__103();
			<ReadStringAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadStringAsync>d__.<>4__this = this;
			<ReadStringAsync>d__.address = address;
			<ReadStringAsync>d__.length = length;
			<ReadStringAsync>d__.encoding = encoding;
			<ReadStringAsync>d__.<>1__state = -1;
			<ReadStringAsync>d__.<>t__builder.Start<SerialDeviceBase.<ReadStringAsync>d__103>(ref <ReadStringAsync>d__);
			return <ReadStringAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int16[])" />
		// Token: 0x0600030C RID: 780 RVA: 0x0000BDD4 File Offset: 0x00009FD4
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, short[] values)
		{
			SerialDeviceBase.<WriteAsync>d__104 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__104();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__104>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int16)" />
		// Token: 0x0600030D RID: 781 RVA: 0x0000BE28 File Offset: 0x0000A028
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, short value)
		{
			SerialDeviceBase.<WriteAsync>d__105 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__105();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__105>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt16[])" />
		// Token: 0x0600030E RID: 782 RVA: 0x0000BE7C File Offset: 0x0000A07C
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, ushort[] values)
		{
			SerialDeviceBase.<WriteAsync>d__106 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__106();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__106>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt16)" />
		// Token: 0x0600030F RID: 783 RVA: 0x0000BED0 File Offset: 0x0000A0D0
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, ushort value)
		{
			SerialDeviceBase.<WriteAsync>d__107 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__107();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__107>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int32[])" />
		// Token: 0x06000310 RID: 784 RVA: 0x0000BF24 File Offset: 0x0000A124
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, int[] values)
		{
			SerialDeviceBase.<WriteAsync>d__108 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__108();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__108>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int32)" />
		// Token: 0x06000311 RID: 785 RVA: 0x0000BF78 File Offset: 0x0000A178
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, int value)
		{
			SerialDeviceBase.<WriteAsync>d__109 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__109();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__109>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt32[])" />
		// Token: 0x06000312 RID: 786 RVA: 0x0000BFCC File Offset: 0x0000A1CC
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, uint[] values)
		{
			SerialDeviceBase.<WriteAsync>d__110 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__110();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__110>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt32)" />
		// Token: 0x06000313 RID: 787 RVA: 0x0000C020 File Offset: 0x0000A220
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, uint value)
		{
			SerialDeviceBase.<WriteAsync>d__111 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__111();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__111>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Single[])" />
		// Token: 0x06000314 RID: 788 RVA: 0x0000C074 File Offset: 0x0000A274
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, float[] values)
		{
			SerialDeviceBase.<WriteAsync>d__112 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__112();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__112>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Single)" />
		// Token: 0x06000315 RID: 789 RVA: 0x0000C0C8 File Offset: 0x0000A2C8
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, float value)
		{
			SerialDeviceBase.<WriteAsync>d__113 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__113();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__113>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int64[])" />
		// Token: 0x06000316 RID: 790 RVA: 0x0000C11C File Offset: 0x0000A31C
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, long[] values)
		{
			SerialDeviceBase.<WriteAsync>d__114 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__114();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__114>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int64)" />
		// Token: 0x06000317 RID: 791 RVA: 0x0000C170 File Offset: 0x0000A370
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, long value)
		{
			SerialDeviceBase.<WriteAsync>d__115 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__115();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__115>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt64[])" />
		// Token: 0x06000318 RID: 792 RVA: 0x0000C1C4 File Offset: 0x0000A3C4
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, ulong[] values)
		{
			SerialDeviceBase.<WriteAsync>d__116 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__116();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__116>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt64)" />
		// Token: 0x06000319 RID: 793 RVA: 0x0000C218 File Offset: 0x0000A418
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, ulong value)
		{
			SerialDeviceBase.<WriteAsync>d__117 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__117();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__117>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Double[])" />
		// Token: 0x0600031A RID: 794 RVA: 0x0000C26C File Offset: 0x0000A46C
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, double[] values)
		{
			SerialDeviceBase.<WriteAsync>d__118 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__118();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__118>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Double)" />
		// Token: 0x0600031B RID: 795 RVA: 0x0000C2C0 File Offset: 0x0000A4C0
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, double value)
		{
			SerialDeviceBase.<WriteAsync>d__119 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__119();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__119>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String)" />
		// Token: 0x0600031C RID: 796 RVA: 0x0000C314 File Offset: 0x0000A514
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value)
		{
			SerialDeviceBase.<WriteAsync>d__120 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__120();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__120>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String,System.Text.Encoding)" />
		// Token: 0x0600031D RID: 797 RVA: 0x0000C368 File Offset: 0x0000A568
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value, Encoding encoding)
		{
			SerialDeviceBase.<WriteAsync>d__121 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__121();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.encoding = encoding;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__121>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String,System.Int32)" />
		// Token: 0x0600031E RID: 798 RVA: 0x0000C3C4 File Offset: 0x0000A5C4
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value, int length)
		{
			SerialDeviceBase.<WriteAsync>d__122 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__122();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.length = length;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__122>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String,System.Int32,System.Text.Encoding)" />
		// Token: 0x0600031F RID: 799 RVA: 0x0000C420 File Offset: 0x0000A620
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value, int length, Encoding encoding)
		{
			SerialDeviceBase.<WriteAsync>d__123 <WriteAsync>d__ = new SerialDeviceBase.<WriteAsync>d__123();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.length = length;
			<WriteAsync>d__.encoding = encoding;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<SerialDeviceBase.<WriteAsync>d__123>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		// Token: 0x040000E3 RID: 227
		private IByteTransform byteTransform;

		// Token: 0x040000E4 RID: 228
		private string connectionId = string.Empty;
	}
}
